home *** CD-ROM | disk | FTP | other *** search
/ PC World 2006 October / PCWorld_2006-10_cd.bin / v cisle / pdffc / ps2pdf995.exe / pdf995 / res / convert / pdf_font.ps < prev    next >
Encoding:
Text File  |  2004-09-01  |  42.5 KB  |  1,303 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: pdf_font.ps,v 1.53.2.5 2004/08/31 04:03:30 ray Exp $
  17. % pdf_font.ps
  18. % PDF font operations.
  19.  
  20. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  21. .currentglobal true .setglobal
  22. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  23. GS_PDF_ProcSet begin
  24. pdfdict begin
  25.  
  26. % We cache the PostScript font in an additional element of the
  27. % font resource dictionary, called PSFont.
  28.  
  29. % ---------------- Encodings ---------------- %
  30.  
  31. /.notdefEncoding 256 { /.notdef } repeat 256 packedarray def
  32.  
  33. % Apply a list of differences to an Encoding.
  34. % Note that the differences may cause the array to grow.
  35. /updateencoding {    % <encoding|null> <differences> updateencoding <enc'>
  36.     % Calculate the length of the result.
  37.   % in case the incoming Encoding is null, use .notdefEncoding
  38.   exch dup null eq { pop .notdefEncoding } if
  39.   0 0 3 index {
  40.     dup type /nametype ne { exch pop oforce } { pop 1 add } ifelse
  41.     % Differences list may not be in order, update the largest_index
  42.     % stack: <Differences> <encoding> <largest_index> <at_index>
  43.     2 copy lt { exch pop dup } if    % at_index is new largest
  44.   } forall
  45.   pop 1 index length .max array dup 0 4 -1 roll putinterval
  46.   exch 0 exch {
  47.         % Stack: enc' code element
  48.     dup type /nametype ne
  49.       { exch pop oforce }
  50.       { 3 copy put pop 1 add }
  51.     ifelse
  52.   } forall pop
  53. } bdef
  54.  
  55. % Get the Encoding for a font.
  56. /getencoding        % <base-encoding> <font-resource> getencoding <enc>
  57.  { /Encoding knownoget
  58.     { dup type /nametype eq
  59.        {
  60.          % The published PDF specification says the Encoding name
  61.          % "must be" one of the 3 predefined Encodings, implying
  62.          % that an error should occur if it isn't.  However, Acrobat
  63.          % Reader simply ignores unknown names, and since there are
  64.          % some buggy applications that rely on this, we do the same.
  65.  
  66.          dup dup dup /MacRomanEncoding eq
  67.          exch /MacExpertEncoding eq or 
  68.          exch /WinAnsiEncoding eq or
  69.            { exch pop findencoding
  70.            }
  71.            { pop
  72.            }
  73.          ifelse
  74.        }
  75.        { dup /BaseEncoding knownoget
  76.       { findencoding 3 -1 roll pop exch
  77.       }
  78.      if
  79.      /Differences knownoget { updateencoding } if
  80.        }
  81.       ifelse
  82.     }
  83.    if
  84.  } bdef
  85.  
  86. % Define a font using it's FontName as the key.
  87. % Adjust a font according to the Encoding and Widths in the font resource.
  88. /adjustfont {        % <font-resource> <font> adjustfont <font'>
  89.   getfontencoding
  90.   getfontmetrics 5 -1 roll pop .updatefont { dup /FontName get exch definefont } if
  91. } bind def
  92.  
  93. % Get the (possibly modified) encoding of a font.
  94. /getfontencoding {    % <font-resource> <font> getfontencoding
  95.             %   <font-resource> <font> <Encoding|null>
  96.   1 index /Encoding known {
  97.     dup /Encoding knownoget { 2 index getencoding } { null } ifelse
  98.   } {
  99.     null
  100.   } ifelse
  101. } bdef
  102.  
  103. % Returns true if the current glyph is in the Differences array at
  104. % the specified index value. This is needed because the Widths
  105. % array may map to the same glyph at different positions from the
  106. % Encoding. We want to use the Width that was associated with the
  107. % one specified in the Encoding::Differences list.
  108. /match_in_diff     % <Differences> <index> <glyphname> match_in_diff <bool>
  109. { false 4 1 roll 0 4 -1 roll    % stack: false index glyphname at_index==0 Differences
  110.   { exch 1 index type /nametype ne {
  111.       % stack: false index glyphname Diff_element at_index 
  112.       pop    % Diff_element is new at_index
  113.     } {
  114.       % stack: false index glyphname Diff_element at_index 
  115.       exch 2 index eq {
  116.         % stack: false index glyphname at_index 
  117.     dup 3 index eq {
  118.           true 5 1 roll    % stack: true false index glyphname at_index
  119.           pop exit
  120.         } if
  121.       } if
  122.       1 add        % at_index++ stack: false index glyphname at_index' 
  123.     } ifelse
  124.   } forall
  125.   % stack: true  false index     glyphname
  126.   %  or  : false index glyphname at_index
  127.   pop pop pop
  128. } bdef
  129.  
  130. /unique_name {  % <dict> </root> unique_name </unique> 
  131.   .namestring       % <<>> (root)
  132.   0 1 65535 {
  133.     5 string cvs    % <<>> (root) (0)
  134.     1 index exch    % <<>> (root) (root) (0)
  135.     concatstrings   % <<>> (root) (root0)
  136.     dup             % <<>> (root) (root0) (root0)
  137.     3 index exch    % <<>> (root) (root0) <<>> (root0)
  138.     known not {
  139.       exch pop exit % <<>> (root0)
  140.     } if
  141.     pop
  142.   } for
  143.   exch pop cvn      % /root0
  144. } bdef
  145.                                
  146. % Get the metrics of a font, if specified.
  147. /getfontmetrics {    % <font-resource> <font> <Encoding|null> getfontmetrics
  148.             %   <font-resource> <font> <Encoding|null>
  149.             %   <Metrics|null> <GlyphMap|null>
  150.   2 index /Widths known {
  151.     dup null eq { pop dup /Encoding get } if
  152.     4 dict begin
  153.       dup length dict
  154.       /Metrics exch def
  155.       /Encoding exch def
  156.       /GlyphMap //null def
  157.       exch
  158.       dup /Widths oget /Widths exch def
  159.         % Stack: font font-res
  160.         % Note that widths are always based on a 1000-unit
  161.         % character space, but the FontMatrix may specify
  162.         % some other scale factor.  Compensate for this here,
  163.         % by scaling the Widths if necessary.
  164.       0.001 2 index /FontMatrix get 0 get div
  165.         % Stack: font font-res mscale
  166.       1 index /FirstChar oget dup 1 4 index /LastChar oget
  167.        {    % Stack: font font-res mscale first-char index
  168.      Encoding 1 index dup 2 index length ge {
  169.            (   **** Warning: Font Encoding array size is smaller than character range.\n)
  170.            pdfformaterror
  171.        pop pop /.notdef
  172.          } {
  173.        get
  174.      } ifelse
  175.      Widths 2 index 4 index sub dup 2 index length ge {
  176.            (   **** Warning: Font Widths array size is smaller than character range.\n)
  177.            pdfformaterror
  178.            % use MissingWidth if it's available, if not, default to 1000 (full width)
  179.        pop pop 4 index /FontDescriptor knownoget {
  180.          /MissingWidth knownoget not { 1000    } if
  181.        } { 1000 } ifelse
  182.          } {
  183.        get
  184.      } ifelse
  185.          % Stack: font font-res mscale first-char index charname width
  186.      4 index mul
  187.         % The following 'loop' is only context for 'exit'.
  188.      {    
  189.         % Work around a bug in pdfTeX, which can generate Encoding
  190.         % vectors containing nulls :
  191.        1 index //null eq { exit } if
  192.         % There is a hack here to deal with encodings where the
  193.         % same character appears more than once, because the Metrics
  194.         % dictionary works by character name, not by character code.
  195.         % We prefer to take (1) non-zero width, and (2) width for 
  196.         % the character name which appears in Differences. If the
  197.         % character name appears in Differences, use the Width that
  198.         % corresponds to the index in differences.
  199.        dup 0 eq { exit } if
  200.        Metrics 2 index .knownget not { 0 } if 0 ne {
  201.          5 index /Encoding knownoget not { exit } if
  202.          dup type /dicttype ne { pop exit } if
  203.          /Differences knownoget not { exit } if
  204.          3 index 3 index //match_in_diff exec not { exit } if
  205.        } if
  206.                 % Create a new glyph for a character that maps to an existing glyph
  207.                 % with a different width and passes all the tests above.
  208.            Metrics 2 index .knownget {
  209.              1 index ne
  210.            } {
  211.              //false
  212.            } ifelse {
  213.              GlyphMap //null eq {
  214.                /Encoding Encoding dup length array copy def
  215.                /GlyphMap 4 dict def
  216.              } if
  217.              Metrics 2 index //unique_name exec
  218.                 % Stack: font font-res mscale first-char index charname width new_name
  219.              Encoding 4 index 2 index put
  220.              GlyphMap 1 index 5 -1 roll put
  221.              exch
  222.                 % Stack: font font-res mscale first-char index new_name width
  223.            } if
  224.            2 copy Metrics 3 1 roll put
  225.        exit
  226.      } loop
  227.      pop pop pop
  228.        }
  229.       for pop
  230.         % Now fill in the MissingWidth for any encoded characters
  231.         % that aren't in Metrics already.  Note that built-in
  232.         % fonts may have Widths/FirstChar/LastChar but no
  233.         % FontDescriptor, so we must check for this.
  234.         % Stack: font font-res mscale
  235.       1 index /FontDescriptor knownoget {
  236.     Metrics exch
  237.     /MissingWidth knownoget { 2 index mul } { 0 } ifelse exch
  238.     Encoding {
  239.         % Stack: font font-res mscale missing-width metrics charname
  240.         % Work around the abovementioned pdfTeX bug.
  241.       dup //null ne {
  242.         2 copy known not { 2 copy 4 index put } if pop
  243.       } {
  244.         pop
  245.       } ifelse
  246.     } forall pop pop pop
  247.       } {
  248.     pop
  249.       } ifelse
  250.     exch Encoding Metrics GlyphMap end
  251.   } {
  252.     //null //null
  253.   } ifelse
  254. } bdef
  255.  
  256. currentdict /unique_name undef
  257. currentdict /match_in_diff undef
  258.  
  259. % ---------------- Descriptors ---------------- %
  260.  
  261. % Partial descriptors for the 14 built-in fonts.  Note that
  262. % from PDF 1.1 to PDF 1.2, the meaning of the Flag 6 in the FontDescriptor
  263. % object has undergone a subtle change in its meaning which has serious
  264. % consequences for searching with Acrobat:
  265. % In PDF 1.1, the flag meant: Font has StandardEncoding
  266. % In PDF 1.2, the flag means: Font has (subset of) StandardRomanCharacterSet
  267. /standardfontdescriptors mark
  268.   /Courier mark /Flags 16#23 .dicttomark
  269.   /Courier-Oblique 1 index
  270.   /Courier-Bold 1 index
  271.   /Courier-BoldOblique 1 index
  272.   /Helvetica mark /Flags 16#20 .dicttomark
  273.   /Helvetica-Oblique 1 index
  274.   /Helvetica-Bold 1 index
  275.   /Helvetica-BoldOblique 1 index
  276.   /Times-Roman mark /Flags 16#22 .dicttomark
  277.   /Times-Bold 1 index
  278.   /Times-Italic mark /Flags 16#62 .dicttomark
  279.   /Times-BoldItalic 1 index
  280.   /Symbol mark /Flags 16#4 .dicttomark
  281.   /ZapfDingbats 1 index
  282. .dicttomark readonly def
  283.  
  284. % ---------------- Utilities ---------------- %
  285.  
  286. /.pdforigfontcache_g 20 dict def
  287. currentglobal false setglobal
  288. systemdict /.pdforigfontcache_l 20 dict .forceput
  289. setglobal
  290.  
  291. % Cache original fonts to prevent adjustfont to accumulate changes.
  292. /pdfcachefont {   % <font_name> pdfcachefont <font>
  293.   dup //.pdforigfontcache_g exch .knownget {
  294.     exch pop
  295.   } {
  296.     dup .pdforigfontcache_l exch .knownget {
  297.       exch pop
  298.     } {
  299.       dup findfont dup    
  300.       dup gcheck { //.pdforigfontcache_g } { .pdforigfontcache_l } ifelse
  301.                      % Stack : font_name font font cache
  302.       4 2 roll .growput
  303.     } ifelse
  304.   } ifelse
  305. } bind def
  306.  
  307. % Find a font (except for embedded ones), and adjust its encoding if necessary.
  308. /.pdfdfndict mark
  309.   /defaultfontname /Helvetica
  310. .dicttomark readonly def
  311. /pdffindfont {        % <font-resource> <fontname> pdffindfont <font>
  312.         % If the font isn't available, synthesize one based on
  313.         % its descriptor.
  314.   dup /Font resourcestatus {
  315.     pop pop pdfcachefont
  316.   } {
  317.     1 index /FontDescriptor knownoget {
  318.         % Stack: font-res fontname fontdesc
  319.       dup /Flags oget
  320.       dup 16#40 and -6 bitshift        % 1, oblique/italic
  321.       1 index 16#40000 and -17 bitshift add    % 2, bold
  322.       exch 16#2 and 2 bitshift add    % 8, serif
  323.         % We should look at the fixed flag, too.
  324.         % Stack: font-res fontname fontdesc properties
  325.  
  326.                 % Even though /FontName is a required key in FontDescriptor dict
  327.                 % (As of the PDF 1.4 Reference Manual), In the case of missing 
  328.                 % /FontName key, we substitue /BaseFont for the value of /FontName.
  329.                 % Yet another case of broken PDF's that Adobe Reader accepts.
  330.       1 index dup /FontName known {
  331.         /FontName oget exch
  332.       } {
  333.         (   **** FontDescriptor missing required /FontName key. BaseFont name used.\n)
  334.         pdfformaterror
  335.         pop 2 index exch    % grab the BaseFont from the stack.
  336.       } ifelse
  337.         % Analyzes font name and extract "Narrow" property
  338.         % which is not described by the FontDescriptor Flags.
  339.       0 2 index .fontnameproperties 4 and or
  340.         % Rebind the default font name to Helvetica so that
  341.         % fonts with no properties are handled correctly.
  342.       //.pdfdfndict begin .substitutefontname end
  343.         % Stack: font-res fontname fontdesc substname|null
  344.       Fontmap 1 index known not {
  345.         % No available good substitution, use the standard one.
  346.     pop 1 index .substitutefont
  347.       } if
  348.       dup 3 index ne QUIET not and {
  349.     (Substituting font ) print dup =only
  350.     ( for ) print 2 index =only (.) = flush
  351.       } if
  352.       pdfcachefont
  353.         % Stack: font-res fontname fontdesc font
  354.         % If this is a small-caps font, replace the CharString
  355.         % entries for a..z.
  356.       exch /Flags oget 16#20000 and 0 ne {
  357.     true .copyfontdict
  358.     dup /CharStrings 2 copy get dup length dict .copydict
  359.     % stack: font-res fontname font font /CharStrings CharStringsdict
  360.     5 index /FirstChar get 97 .max
  361.     6 index /LastChar get 122 .min 1 exch {
  362.         % Stack: font-res fontname font' font' /CharStrings charstrings code
  363.         % Note that this only remaps a-z, not accented characters.
  364.       6 index /Widths oget 1 index 8 index /FirstChar get sub oget
  365.       1 string dup 0 5 -1 roll put
  366.         % Stack: font-res font' font' /CharStrings charstrings code
  367.         %   width (x)
  368.       2 index exch dup cvn exch
  369.       dup 0 2 copy get 32 sub put 4 -1 roll {
  370.             % Stack: operand (X) width
  371.         0 setcharwidth exch pop
  372.         currentfont /FontMatrix get matrix invertmatrix concat
  373.         0.7 dup scale 0 0 moveto show
  374.       } /exec cvx 4 packedarray cvx put
  375.     } for put
  376.       } if
  377.       dup /FontName get 2 index ne {
  378.         true .copyfontdict
  379.         2 copy exch /FontName exch put
  380.       } if
  381.       definefont
  382.     } {
  383.         % No descriptor available, use the default algorithm.
  384.       pdfcachefont
  385.     } ifelse
  386.   } ifelse
  387.   exch pop
  388. } bdef
  389.  
  390. % ---------------- Type 1 fonts ---------------- %
  391.  
  392. /buildType1        % <Type1-font-resource> buildType1 <font>
  393.  { dup /BaseFont get pdffindfont
  394.  } bdef
  395.  
  396. % The state dictionary for the embedded Type 1 font reading procedure
  397. % has the following keys and values:
  398. %    data - stream (filter)
  399. %    buffer, buffer2 - string
  400. %    hexify - procedure to convert buffer to hex if needed
  401. %    leftstr - string containing (non-negative) integer
  402. %    sectionstr - string containing a character 0 .. 3
  403. %    stream - (stream) dictionary
  404. %    proc - procedure of the form {-dict- type1read}
  405. %       pfbhdr - string containing 16#80 if PFB, 0 otherwise
  406. % When the procedure is executing, this dictionary is current.
  407. % leftstr and sectionstr are strings so that we can change their values
  408. % reliably in case the font executes a restore!
  409. % We also have to do something special about embedded fonts that
  410. % execute definefont more than once -- that is the function of topFontDict.
  411.  
  412. % Read an embedded Type 1 font.
  413. /readfontfilter {    % <proc> readfontfilter <filter>
  414.   0 () /SubFileDecode filter
  415. } bdef
  416. /readtype1dict 5 dict dup begin
  417.   /definefont {
  418.     dup topFontDict eq topFontDict null eq or {
  419.       dup wcheck not { dup length dict copy } if
  420.       exch pop savedFontName exch
  421.     } if
  422.     //systemdict /definefont get exec
  423.   } bdef
  424.   /eexec {
  425.     % Assume the font dictionary is directly below the file on the stack
  426.     count 0 gt { /topFontDict 2 index cvlit store } if
  427.     //.eexec_param_dict /eexecDecode filter
  428.     //systemdict begin readtype1dictcopy begin cvx stopped
  429.     currentdict readtype1dictcopy eq { end } if
  430.     currentdict //systemdict eq { end } if
  431.      { stop } if
  432.   } bdef
  433. end readonly def
  434. /readtype1 {        % <font-resource> <stream-dict> readtype1 <font>
  435.         % Read the definition, using a procedure-based filter
  436.         % that turns binary/hex conversion on and off
  437.         % at the right times.
  438.    1 index exch
  439.    PDFfile fileposition 3 1 roll
  440.    11 dict begin
  441.      /leftstr (          ) 10 string copy def
  442.        dup /Length1 oget leftstr cvs pop
  443.      /sectionstr <00> 1 string copy def
  444.      /pfbhdr <00> 1 string copy def
  445.      /stream 1 index def
  446.      true resolvestream /data exch def
  447.      /buffer 1000 string def        % arbitrary
  448.      /buffer2 buffer length 2.1 div cvi 1 sub string def
  449.      /hexify /buf2hex load def
  450.    currentdict end
  451.    /type1read cvx 2 array astore cvx dup 0 get /proc 2 index put
  452.    readfontfilter
  453.         % Some buggy embedded fonts leave extra junk on the stack,
  454.         % so we have to make a closure that records the stack depth
  455.         % in a fail-safe way. Also restore dictstack depth.
  456.    //systemdict begin
  457.         % The PDF specification is somewhat muddy about whether
  458.         % an embedded font's name is supposed to be the BaseFont
  459.         % from the Font object or the FontName from the descriptor.
  460.         % Acrobat Distiller requires the former.  Save away the
  461.         % name so we can substitute it at definefont time.
  462.    //readtype1dict dup length 3 add dict copy begin
  463.    1 index /BaseFont oget /savedFontName exch def
  464.    /topFontDict null def
  465.    /readtype1dictcopy currentdict def
  466.     { run } aload pop count 1 sub 2 packedarray cvx exec
  467.     % clean up the dictstack
  468.     { currentdict /topFontDict known not { end } { end end exit } ifelse } loop
  469.    count exch sub { pop } repeat
  470.    PDFfile 3 -1 roll setfileposition
  471.    /BaseFont oget pdfcachefont
  472.    exch pop
  473.  } bdef
  474.  
  475. % Execute the appropriate reading procedure.
  476. /type1read        % <dict> type1read <string>
  477.  { begin leftstr cvi
  478.     { type1read0 type1read1 type1read2 type1read3 } sectionstr 0 get get exec
  479.    (          ) leftstr copy cvs pop end
  480.  } bdef
  481.  
  482. % Read the next block of data into the buffer.
  483. /type1readdata        % <left> <buffer> type1readdata <substring> <left'>
  484.  { 0 2 index 2 index length .min getinterval
  485.         % Adobe requires readstring to signal an error if given
  486.         % an empty string.  Work around this nonsense here.
  487.    dup length 0 ne { data exch readstring pop } if
  488.    dup length 3 -1 roll exch sub
  489.    PDFDEBUG
  490.     { dup =only ( read ) print
  491.       1 index length =only (: ) print
  492.       1 index == flush
  493.     } if
  494.  } bdef
  495.  
  496. % Read the initial byte to see if we need to skip a 6 byte PFB header
  497. /type1read0 {         % <left> type1read0 <string> <left'>
  498.   sectionstr 0 1 put    % either way we go to the next stage
  499.   pfbhdr type1readdata
  500.   1 index 0 get 16#80 eq {
  501.     (   **** Warning: Embedded Type1 font in PFB format is not valid PDF.\n)
  502.     pdfformaterror
  503.     PDFDEBUG { (skipping PFB header) = flush } if
  504.     exch pop buffer 0 5 getinterval type1readdata exch
  505.     dup 4 get 256 mul 1 index 3 get add 256 mul
  506.     1 index 2 get add 256 mul 1 index 1 get add
  507.     PDFDEBUG { (PFB segment length = ) print dup = } if
  508.     exch pop  % discard the string keeping the PFB segment length
  509.     2 copy ne {
  510.       (   **** Warning: Type 1 PFB segment length and Length 1 value do not match.\n)
  511.       pdfformaterror
  512.       exch     % keep the PFB length instead
  513.     } if
  514.     pop
  515.     buffer type1readdata    % go ahead and read a block
  516.   }
  517.   if    % if not PFB, return pfbhdr string (first char of file, usually %).
  518. } bdef
  519.  
  520. % Read the next block of the initial text portion.
  521. /type1read1 {        % <left> type1read1 <string> <left'>
  522.   PDFDEBUG { (read1 ) print } if
  523.   dup 0 eq {
  524.     pop sectionstr 0 2 put
  525.     stream /Length2 oget
  526.             % Determine whether to hexify data for eexec.
  527.     dup 8 lt {
  528.       type1read2    % Hexify.
  529.     } {
  530.       PDFDEBUG { (read2 ) print } if
  531.       pfbhdr 0 get 16#80 eq {
  532.         % eat 6 more bytes of PFB junk before proceeding
  533.     PDFDEBUG { (skipping PFB header in segment 2) = flush } if
  534.     buffer 0 6 getinterval type1readdata exch
  535.         dup 5 get 256 mul 1 index 4 get add 256 mul
  536.     1 index 3 get add 256 mul 1 index 2 get add
  537.         PDFDEBUG { (PFB segment length = ) print dup = } if
  538.     exch pop  % discard the string keeping the PFB segment length
  539.     2 copy ne {
  540.           (   **** Warning: Type 1 PFB segment length and Length 2 value do not match.\n)
  541.           pdfformaterror
  542.       exch         % keep the PFB length instead
  543.     } if
  544.       pop
  545.       } if
  546.       buffer2 type1readdata exch
  547.             % The check doesn't have to be 100% accurate:
  548.             % hexifying is always OK.
  549.       dup 0 8 getinterval 0 exch { or } forall
  550.       128 ge {
  551.     /hexify { } store
  552.     /buffer2 buffer def    % We don't need an intermediate buffer.
  553.       } if hexify exch
  554.     } ifelse
  555.   } {
  556.     buffer type1readdata
  557.   } ifelse
  558. } bdef
  559.  
  560. % Convert a string from binary to hex for eexec.
  561. % Free variables: buffer.
  562. /buf2hex {        % <string> buf2hex <hexstring>
  563.   buffer /ASCIIHexEncode filter dup 3 -1 roll writestring closefile
  564.   buffer (>) search pop exch pop exch pop
  565. } bdef
  566.  
  567. % Read the next block of the encrypted portion.
  568. /type1trailer
  569. (0000000000000000000000000000000000000000000000000000000000000000\n\
  570. 0000000000000000000000000000000000000000000000000000000000000000\n\
  571. 0000000000000000000000000000000000000000000000000000000000000000\n\
  572. 0000000000000000000000000000000000000000000000000000000000000000\n\
  573. 0000000000000000000000000000000000000000000000000000000000000000\n\
  574. 0000000000000000000000000000000000000000000000000000000000000000\n\
  575. 0000000000000000000000000000000000000000000000000000000000000000\n\
  576. 0000000000000000000000000000000000000000000000000000000000000000\n\
  577. cleartomark\n)
  578. readonly def
  579. /type1read2 {        % <left> type1read2 <string> <left'>
  580.   PDFDEBUG { (read2 ) print } if
  581.    dup 0 eq
  582.     { pop sectionstr 0 3 put
  583.       stream /Length3 oget
  584.       dup 0 eq
  585.        { PDFDEBUG { (trailer ) print } if
  586.      type1trailer exch
  587.        }
  588.        { 
  589.          pfbhdr 0 get 16#80 eq {
  590.            % eat 6 more bytes of PFB junk before proceeding
  591.        PDFDEBUG { (skipping PFB header in segment 3) = flush } if
  592.        buffer 0 6 getinterval type1readdata exch
  593.            dup 5 get 256 mul 1 index 4 get add 256 mul
  594.        1 index 3 get add 256 mul 1 index 2 get add
  595.            PDFDEBUG { (PFB segment length = ) print dup = } if
  596.        exch pop  % discard the string keeping the PFB segment length
  597.        2 copy ne {
  598.            (   **** Warning: Type 1 PFB segment length and Length 3 value do not match.\n)
  599.            pdfformaterror
  600.          exch     % keep the PFB length instead
  601.        } if
  602.        pop
  603.          } if
  604.          type1read3
  605.        }
  606.       ifelse
  607.     }
  608.     { buffer2 type1readdata exch hexify exch
  609.     }
  610.    ifelse
  611. } bdef
  612.  
  613. % Read the next block of the final text portion.
  614. % When finished, this procedure returns an empty string.
  615. /type1read3        % <left> type1read3 <string> <left'>
  616.  { PDFDEBUG { (read3 ) print } if
  617.    buffer type1readdata
  618.  } bdef
  619.  
  620. % ---------------- Type 3 fonts ---------------- %
  621.  
  622. /buildType3 {        % <Type3-font-resource> buildType3 <font>
  623.   8 dict begin
  624.     /FontType 3 def
  625.     /Resources 1 index /Resources knownoget { oforce } { 0 dict } ifelse def
  626.     /FontBBox 1 index /FontBBox get cvx def
  627.     /FontMatrix 1 index /FontMatrix oget def
  628.     /CharProcs 1 index /CharProcs oget def
  629.     1 index /Widths knownoget {
  630.       /Widths exch def
  631.       /FirstChar 1 index /FirstChar oget def
  632.       /LastChar 1 index /LastChar oget def
  633.     } if
  634.     /FontName 1 index /Name .knownget not { 
  635.        PDFfile fileposition 16 10 string cvrs cvn
  636.     } if def
  637.  
  638.     /Encoding .notdefEncoding 2 index getencoding def
  639.         % We have to define BuildChar rather than BuildGlyph:
  640.         % there is no PDF equivalent of glyphshow, and we need
  641.         % the character code to access the Widths.
  642.     /BuildChar {
  643.         % Stack: font charcode
  644.       1 index begin 3 dict begin
  645.       /Font 3 -1 roll def /CharCode 1 index def
  646.       % Make unknown characters map to /.notdef
  647.       Encoding exch get dup CharProcs exch known
  648.         { CharProcs exch oget }
  649.     { pop CharProcs /.notdef oget }
  650.       ifelse
  651.       PDFfile fileposition exch
  652.       false resolvestream
  653.         % Stack: filepos stream
  654.         % Don't let setgcolor set the color inside the BuildGlyph
  655.         % procedure, because this causes an /undefined error.
  656.       q null /FillColor gput null /StrokeColor gput
  657.       Font /Resources get exch pdfopdict .pdfruncontext
  658.       Q
  659.       PDFfile exch setfileposition
  660.       end end
  661.     } bdef
  662.     FontName currentdict end definefont exch pop
  663. } bdef
  664. /.adjustcharwidth {    % <wx> <wy> .adjustcharwidth <wx'> <wy'>
  665.   /Widths where {
  666.     begin
  667.     CharCode FirstChar ge CharCode LastChar le and {
  668.       exch pop Widths CharCode FirstChar sub get exch
  669.     } if end
  670.   } if
  671. } bdef
  672.  
  673. % ---------------- TrueType fonts ---------------- %
  674.  
  675. /TTfonts mark
  676.   /Arial /Helvetica
  677.   /Arial,Italic /Helvetica-Oblique
  678.   /Arial,Bold /Helvetica-Bold
  679.   /Arial,BoldItalic /Helvetica-BoldOblique
  680.   /CourierNew /Courier
  681.   /CourierNew,Bold /Courier-Bold
  682.   /TimesNewRoman /Times-Roman
  683.   /TimesNewRoman,Italic /Times-Italic
  684.   /TimesNewRoman,Bold /Times-Bold
  685.   /TimesNewRoman,BoldItalic /Times-BoldItalic
  686. .dicttomark readonly def
  687.  
  688. /buildTrueType {    % <TrueType-font-resource> buildTrueType <font>
  689.   dup /BaseFont oget
  690.   (   **** Warning: Fonts with Subtype = /TrueType should be embedded.\n) pdfformaterror
  691.   (                 But ) pdfformaterror dup =string cvs pdfformaterror ( is not embedded.\n) pdfformaterror
  692.   dup TTfonts exch .knownget {
  693.     QUIET not {
  694.       (Substituting font ) print dup =only
  695.       ( for ) print 1 index =only (.) = flush
  696.     } if
  697.     exch 3 1 roll pdffindfont
  698.     true .copyfontdict
  699.     2 copy exch /FontName exch put
  700.     definefont
  701.   } {
  702.     pdffindfont
  703.   } ifelse
  704. } bdef
  705.  
  706. % Read an embedded TrueType font.
  707. /readtruetype {        % <font-resource> <stream-dict> readtruetype <font>
  708.         % This is much simpler than readtype1, because we don't
  709.         % have to deal with the tripartite .PFB format.
  710.   1 index exch
  711.   PDFfile fileposition 3 1 roll
  712.   true resolvestream readfontfilter
  713.         % Stack: filepos fontres stream
  714.   1 index /Subtype get /CIDFontType2 eq {
  715.     .loadttcidfont
  716.         % Stack: filepos fontres cidfont
  717.   } {
  718.                                   % filepos fontres stream
  719.     1 index /FontDescriptor oget          % filepos fontres stream fd   
  720.     /Flags get 4 and 0 ne                 % filepos fontres stream is_symbolic
  721.     dup {
  722.       2 index null exch getencoding       % filepos fontres stream is_symbolic Encoding
  723.       dup 4 index exch                    % filepos fontres stream is_symbolic Encoding fontres Encoding
  724.       /prebuilt_encoding exch put         % filepos fontres stream is_symbolic Encoding
  725.     } {
  726.       null
  727.     } ifelse
  728.     .loadpdfttfont
  729.   } ifelse
  730.   exch pop
  731.   PDFfile 3 -1 roll setfileposition
  732.         % Ignore both the Encoding and the Widths.
  733.   exch pop
  734. } bdef
  735.  
  736. % ---------------- Type 0 fonts ---------------- %
  737.  
  738. % Predefine the known CMaps, but only create them on demand.
  739. /knownCMaps mark
  740.   /Identity-H { /Identity-H 0 makeIdentityCMap }
  741.   /Identity-V { /Identity-V 1 makeIdentityCMap }
  742. .dicttomark def
  743.  
  744. /makeIdentityCMap {        % <cmapname> <wmode> .makeIdentityCMap -
  745.   .currentglobal true .setglobal 3 1 roll
  746.   /CIDInit /ProcSet findresource begin
  747.   12 dict begin
  748.     begincmap
  749.     /WMode exch def
  750.     /CMapName exch def
  751.     /CIDSystemInfo 3 dict dup begin
  752.       /Registry (Adobe) def
  753.       /Ordering (Identity) def
  754.       /Supplement 0 def
  755.     end def
  756.     %/CMapName (see above)
  757.     /CMapVersion 1 def
  758.     /CMapType 1 def
  759.     %WMode (see above)
  760.     % The PDF documentation says that these CMaps map CIDs
  761.     % "1 to 65,536".  This is a misprint for 0 to 65,535.
  762.     1 begincodespacerange
  763.     % <0001> <00ff>  <0100> <ffff>
  764.       <0000> <ffff>
  765.     endcodespacerange
  766.     1 begincidrange
  767.     % <0001> <00ff> 1   <0100> <ffff> 256
  768.       <0000> <ffff> 0
  769.     endcidrange
  770.     endcmap
  771.     CMapName currentdict /CMap defineresource
  772.     knownCMaps CMapName 2 index put
  773.   end        % CMap
  774.   end        % CIDInit ProcSet
  775.   exch .setglobal
  776. } bdef
  777.  
  778. /buildType0 {        % <Type0-font-resource> buildType0 <font>
  779.   dup /BaseFont get    % FontName
  780.   1 index /Encoding oget
  781.   dup type /nametype eq {
  782.     dup /CMap resourcestatus {
  783.     pop pop /CMap findresource
  784.     } {
  785.     knownCMaps 1 index .knownget
  786.       { exch pop exec } { /undefined signalerror } ifelse
  787.     } ifelse
  788.   } {
  789.     PDFfile fileposition exch
  790.     dup /CMapName get exch true resolvestream cvx exec
  791.     /CMap findresource
  792.     exch PDFfile exch setfileposition
  793.   } ifelse        % CMap
  794.   [
  795.     3 index /DescendantFonts oget { exec resourcefont } forall
  796.   ]            % subfonts
  797.   composefont
  798.         % Stack: fontres font
  799.   1 index /FontMatrix knownoget {
  800.     dup aload pop true {0 0 1 0 0 1} {3 -1 roll eq and} forall {
  801.       1 index exch makefont exch /FontName get exch definefont
  802.     } {
  803.       pop
  804.     } ifelse
  805.   } if exch pop
  806. } bdef
  807.  
  808. % ---------------- CIDFontType0/2 fonts ---------------- %
  809.  
  810. % Insert metrics into a CIDFont, by saving the PDF W, W2, DW, and DW2
  811. % arrays and using a (currently very inefficient) CDevProc.
  812. % For detail, refer "PDF Reference" 2nd ed., p314 "5.6.3 CIDFonts".
  813. % It notes default DW is 0, but Acrobat Reader uses 1000 as default.
  814. % If DW is 0, currentpoint does not move by default in rendering text
  815. % horizontally, the result is unreadable. You can check it by Acrobat.
  816.  
  817. /.pdfDefaultDW  1000 def
  818. /.pdfDefaultDW2 [ 880 -1000 ] def
  819.  
  820. /addCIDmetrics {    % <CIDFont-resource> <CIDFont> addCIDmetrics <fontdict>
  821.   dup length 5 add dict .copydict
  822.   dup /FID undef
  823.   dup /UniqueID undef
  824.   dup /XUID undef
  825.     % Insert the widths into the font.
  826.  
  827.         % Stack: pdfresource newfont
  828.  
  829.   1 index /DW .knownget {
  830.     1 index /DW 3 -1 roll put
  831.   } {
  832.     dup /DW .pdfDefaultDW put
  833.   } ifelse
  834.  
  835.   1 index /W .knownget {
  836.     dup 2 index /W 3 -1 roll put
  837.     .pdfMakeInternalW 1 index /.internalW 3 -1 roll put
  838.   } if
  839.  
  840.   1 index /DW2 .knownget {
  841.     1 index /DW2 3 -1 roll put
  842.   } {
  843.     dup /DW2 .pdfDefaultDW2 put
  844.   } ifelse
  845.  
  846.   1 index /W2 .knownget {
  847.     dup 2 index /W2 3 -1 roll put
  848.     .pdfMakeInternalW2 1 index /.internalW2 3 -1 roll put
  849.   } if
  850.  
  851.   dup /CDevProc 1 index /CIDWProc load /exec load 3 packedarray cvx put
  852.   exch pop
  853. } bdef
  854.  
  855. /.pdfMakeInternalMTXArray { % <mtx_array> <item_size> .pdfConvertInternalW <mtx_array'>
  856.  
  857.   % convert /W or /W2 to internal expression
  858.   %
  859.   %   mtx_array: original /W or /W2 array
  860.   %   item_size: number of metrics values per CID
  861.   %
  862.   %   for detail of the metrics list format in PDF,
  863.   %   refer PDF Ref. p.317 "Glyph Metrics in CIDFonts".
  864.   % 
  865.   %   format of single entry in internal expression
  866.   %
  867.   %     [
  868.   %       [cid_begin cid_end]
  869.   %       value_is_varied (bool)
  870.   %       [ [values for cid_begin...]
  871.   %         [values for cid_begin + 1]
  872.   %         ... ]
  873.   %     ]
  874.   %
  875.  
  876.   7 dict
  877.   begin
  878.     /itemSize exch def
  879.     /M exch def            % original /W or /W2
  880.     /Msize M length def
  881.     /Mi { M i get } def        % W[i]
  882.     /Mi1 { M i 1 add get } def    % W[i + 1]
  883.     /putMTXEntry <<
  884.       /arraytype   {
  885.          [
  886.            [Mi Mi Mi1 length add 1 sub]
  887.            true
  888.            [
  889.              0 itemSize Mi1 length 1 sub {
  890.                [ exch 1 1 index itemSize add 1 sub { Mi1 exch get } for ]
  891.              } for
  892.            ]
  893.          ]
  894.          /i i 2 add def
  895.       }
  896.       /integertype {
  897.          [
  898.            [Mi Mi1]
  899.            false
  900.            [[ i 2 add 1 i 1 add itemSize add { M exch get } for ]]
  901.          ]
  902.          /i i 3 add def
  903.       }
  904.     >> def
  905.  
  906.     /i 0 def
  907.  
  908.     [ { putMTXEntry Mi1 type get exec i Msize ge { exit } if } loop ]
  909.   end
  910. } def
  911.  
  912. /.pdfMakeInternalW  { dup length 0 gt { 1 .pdfMakeInternalMTXArray } if } def
  913. /.pdfMakeInternalW2 { dup length 0 gt { 3 .pdfMakeInternalMTXArray } if } def
  914.  
  915. /.pdfGetMTXByCID { % <internalMTXArray> <cid>
  916.                    %     .pdfGetMTXByCID
  917.                    %         { <MTXEntry> true | false }
  918.  
  919.   % get values for given CID from internal format of /W or /W2
  920.  
  921.   exch
  922.   {
  923.     {
  924.       dup 0 get {} forall      % Stack: <cid> <entry> <cid_0> <cid_1>
  925.       3 index lt { pop pop false exit } if
  926.       2 index exch sub dup 0 lt { pop pop false exit } if
  927.       1 index 1 get not { pop 0 } if
  928.       exch 2 get exch get true exit
  929.     } loop
  930.     { exit } if
  931.   } forall
  932.   dup type /arraytype eq { exch pop true } { pop false } ifelse
  933. } def
  934.  
  935.  
  936. % Apply the [D]W[2] metrics to a character before displaying.
  937. /CIDWProc {        % <w0x> <w0y> <llx> <lly> <urx> <ury>
  938.             %   <w1x> <w1y> <vx> <vy> <cid> <font> CIDWproc
  939.             %   <w0x'> ... <vy'>
  940.  
  941.   begin % push <font> to currentdict
  942.     % <w1x> <w1y> <vx> <vy> won't be used and replaced, discard now
  943.     5 1 roll pop pop pop pop
  944.  
  945.     {
  946.       currentdict /DW .knownget not {   % no DW
  947.         .pdfDefaultDW exit              % replace <w0x> by defaultDW
  948.       } if
  949.  
  950.       currentdict /.internalW .knownget not {    % no W
  951.         exit                            % use already-stacked DW
  952.       } if
  953.  
  954.       dup length 0 eq {                 % W is null array
  955.         pop                             % discard unusable W
  956.         exit                            % use already-stacked DW
  957.       } if
  958.  
  959.       % W is finite array, try to get W_cid
  960.       2 index .pdfGetMTXByCID {           % got W, discard DW
  961.         exch pop {} forall
  962.         exit
  963.       } if
  964.  
  965.       exit
  966.     } loop
  967.  
  968.     1000 div                    % <w0x'> (normalized W)
  969.     0                           % <w0y'>
  970.  
  971.     % Stack: <w0x> <w0y> <llx> <lly> <urx> <ury> <cid> <w0x'> <w0y'>
  972.     9 -2 roll pop pop           % discard <w0x> <w0y>
  973.     7  2 roll                   % put <w0x'> <w0y'>
  974.  
  975.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <cid>
  976.     0                           % <w1x'>
  977.     exch                        % put <w1x'>
  978.  
  979.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> <cid>
  980.     {
  981.       currentdict /DW2 .knownget not {  % no DW2, use defaultDW2
  982.         .pdfDefaultDW2 exit
  983.       } if
  984.  
  985.       currentdict /.internalW2 .knownget not {   % has DW2, no W2
  986.         exit                            % use already-stacked DW2
  987.       } if
  988.  
  989.       dup length 0 eq {                 % W2 is null array
  990.         pop                             % discard unusable W2
  991.         exit                            % use already-stacked DW2
  992.       } if
  993.  
  994.       2 index .pdfGetMTXByCID {        % got W2_cid, discard DW2
  995.         exch pop
  996.         exit
  997.       } if
  998.  
  999.       % could not get W2_cid
  1000.       exit
  1001.  
  1002.     } loop
  1003.  
  1004.     exch pop                            % discard <cid>
  1005.  
  1006.  
  1007.     % Stack: <w0x'> <w0y'> <llx> <lly> <urx> <ury> <w1x'> { [<vy'> <w1y'>] | [<w1y'> <vx'> <vy'>] }
  1008.     dup length 2 eq {                   % this is DW2
  1009.       {1000 div} forall exch
  1010.       4 index 7 index add 2 div         % <vx'> = (<urx> + <llx>) / 2
  1011.       exch
  1012.     }{                                  % assume W2
  1013.       {1000 div} forall
  1014.     } ifelse
  1015.   end                                   % recover currentdict
  1016.  
  1017. } def
  1018.  
  1019. % <string> <match> tailmatch ==> <pre> true
  1020. %                            ==> <string> false
  1021. /tailmatch {
  1022.   2 copy length 1 index length .min
  1023.   dup 2 index length exch sub exch getinterval
  1024.   1 index eq {
  1025.     length 1 index length exch sub
  1026.     0 exch getinterval true
  1027.   } {
  1028.     pop false
  1029.   } ifelse
  1030. } bind def
  1031.  
  1032. /makeboldfont {
  1033.   16 dict begin
  1034.     /strokewidth exch def
  1035.     /basecidfont exch def
  1036.     /FontMatrix [ 1 0 0 1 0 0 ] def
  1037.  
  1038.     /CIDFontName /.boldfont def
  1039.     /CIDFontType 1 def
  1040.  
  1041.     /basefont-H /.basefont-H /Identity-H [ basecidfont ] composefont def
  1042.     /basefont-V /.basefont-V /Identity-V [ basecidfont ] composefont def
  1043.  
  1044.     /CIDSystemInfo dup basecidfont exch get def
  1045.     /FontBBox [ basecidfont /FontBBox get cvx exec
  1046.       4 2 roll basecidfont /FontMatrix get transform
  1047.       4 2 roll basecidfont /FontMatrix get transform
  1048.     ] def
  1049.  
  1050.     /tmpstr 2 string def
  1051.     /BuildGlyph {
  1052.       gsave
  1053.       exch begin
  1054.         dup 256 idiv tmpstr exch 0 exch put
  1055.         256 mod tmpstr exch 1 exch put
  1056.         rootfont /WMode known { rootfont /WMode get 1 eq } { false } ifelse
  1057.         { basefont-V } { basefont-H } ifelse setfont
  1058.         strokewidth setlinewidth
  1059.         1 setlinejoin
  1060.         newpath
  1061.         0 0 moveto tmpstr false charpath stroke
  1062.         0 0 moveto tmpstr show
  1063.         currentpoint setcharwidth
  1064.       end
  1065.       grestore
  1066.     } bind def
  1067.  
  1068.    currentdict
  1069.   end
  1070.   dup /CIDFontName get exch /CIDFont defineresource
  1071. } bind def
  1072.  
  1073. % <CIDFont-resource> <CIDFontName> findCIDFont <CIDFont-resource> <font>
  1074. %   CIDFont-resource is not modified.
  1075. /findCIDFont {
  1076.   {
  1077.     dup /CIDFont resourcestatus {
  1078.       pop pop /CIDFont findresource
  1079.       exit
  1080.     } if
  1081.  
  1082.     dup dup length string cvs
  1083.     (,Bold) tailmatch {
  1084.       exch pop
  1085.       cvn findCIDFont 0.03 makeboldfont
  1086.       exit
  1087.     } if
  1088.     (,Italic) tailmatch {
  1089.       exch pop
  1090.       cvn findCIDFont
  1091.       [ 1 0 0.3 1 0 0 ] makefont
  1092.       exit
  1093.     } if
  1094.     (,BoldItalic) tailmatch {
  1095.       exch pop
  1096.       cvn findCIDFont 0.03 makeboldfont
  1097.       [ 1 0 0.3 1 0 0 ] makefont
  1098.       exit
  1099.     } if
  1100.     pop
  1101.  
  1102.     1 index /CIDSystemInfo get begin Registry (-) Ordering end
  1103.     concatstrings concatstrings
  1104.     cvn
  1105.     QUIET not {
  1106.       (Substituting ) print dup ==only
  1107.       ( for ) print 1 index ==only (.\n) print
  1108.     } if
  1109.     exch pop
  1110.     /CIDFont findresource
  1111.     exit
  1112.   } loop
  1113. } bdef
  1114.  
  1115. /buildCIDType0 {    % <CIDFontType0-font-resource> buildCIDType0 <font>
  1116.   dup /BaseFont get findCIDFont exch pop
  1117. } bdef
  1118.  
  1119. /buildCIDType2 {    % <CIDFontType2-font-resource> buildCIDType2 <font>
  1120.   dup /BaseFont get findCIDFont exch pop
  1121. } bdef
  1122.  
  1123. /processCIDToGIDMap { % <fontres> <cidfont> processCIDToGIDMap <fontres> <cidfont>
  1124.   1 index /CIDToGIDMap knownoget {
  1125.     PDFfile fileposition 4 1 roll
  1126.     dup /Identity eq {
  1127.       pop
  1128.     } {
  1129.       true resolvestream
  1130.         % Stack: filepos fontres font mapstream
  1131.     % Can't know the length of the decompressed stream, so allocate a big buffer...
  1132.       dup 65534 string readstring {
  1133.       % Length exceeded max string size, use an array of two strings
  1134.         1 index 65534 string readstring pop   % maybe a null string - not important.
  1135.         2 array astore
  1136.                     % Stack: filepos fontres font mapstream array
  1137.            dup 1 get length 65534 add
  1138.       } {
  1139.         dup length
  1140.         } ifelse
  1141.       2 idiv
  1142.         % Stack: filepos fontres font mapstream array/string CIDCount
  1143.       3 index exch /CIDCount exch put
  1144.       exch closefile exch
  1145.       dup /CIDMap 4 -1 roll put
  1146.     } ifelse
  1147.     3 2 roll PDFfile exch setfileposition
  1148.   } if
  1149. } bdef
  1150.  
  1151. % Adjust a CIDFontType0 DW[2] in the font resource.
  1152. /adjustCIDType0 {        % <font-resource> <font> adjustfont <font'>
  1153.   addCIDmetrics
  1154.   dup /CIDFontName get exch /CIDFont defineresource
  1155. } bind def
  1156.  
  1157. % Adjust a CIDFontType2 DW[2] and CIDToGIDMap in the font resource.
  1158. /adjustCIDType2 {        % <font-resource> <font> adjustfont <font'>
  1159.   addCIDmetrics
  1160.   processCIDToGIDMap
  1161.   dup /CIDFontName get exch /CIDFont defineresource
  1162. } bind def
  1163.  
  1164. % ---------------- Other embedded fonts ---------------- %
  1165.  
  1166. /fontloadprocs mark
  1167.   /Type1C /readType1C cvx
  1168.   /CIDFontType0C /readCIDFontType0C cvx
  1169. .dicttomark readonly def
  1170.  
  1171. % Read an embedded compressed font.
  1172. /readType1C {        % <font-resource> <stream-dict> readType1C <font>
  1173.   1 index exch
  1174.   PDFfile fileposition 3 1 roll
  1175.   dup true resolvestream dup readfontfilter
  1176.         % Stack: pos resource streamdict stream filter
  1177.   3 index /FontDescriptor oget /FontName oget
  1178.   1 index FRD
  1179.   closefile closefile pop
  1180.   PDFfile 3 -1 roll setfileposition
  1181.   /FontDescriptor oget /FontName oget pdfcachefont
  1182.   exch pop
  1183. } bdef
  1184.  
  1185. % Read an embedded CFF CIDFont.
  1186. /readCIDFontType0C {  % <font-resource> <stream-dict> readCIDFontType0C <font>
  1187.   PDFfile fileposition 3 1 roll
  1188.   dup true resolvestream dup readfontfilter
  1189.         % Stack: pos resource streamdict stream filter
  1190.   3 index /FontDescriptor oget /FontName oget
  1191.   1 index FRD
  1192.   closefile closefile pop
  1193.   PDFfile 3 -1 roll setfileposition
  1194.         % Some broken Adobe software produces PDF files in which
  1195.         % the FontName of the CFF font and the FontName in the
  1196.         % FontDescriptor don't match the BaseFont in the font.
  1197.         % Use the FontName, rather than the BaseFont, here.
  1198.   dup /FontDescriptor oget /FontName oget /CIDFont findresource
  1199.   addCIDmetrics dup /CIDFontName get exch /CIDFont defineresource
  1200. } bdef
  1201.  
  1202. % ---------------- Font lookup ---------------- %
  1203.  
  1204. /fonttypeprocs mark        % <font-resource> -proc- <font>
  1205.   /Type0 //buildType0
  1206.   /Type1 //buildType1
  1207.   /MMType1 //buildType1
  1208.   /Type3 //buildType3
  1209.   /TrueType //buildTrueType
  1210.   /CIDFontType0 //buildCIDType0
  1211.   /CIDFontType2 //buildCIDType2
  1212. .dicttomark readonly def
  1213.  
  1214. /adjustfonttypes mark
  1215.   /Type1 //adjustfont
  1216.   /MMType1 //adjustfont
  1217.   /TrueType //adjustfont
  1218.   /CIDFontType0 //adjustCIDType0
  1219.   /CIDFontType2 //adjustCIDType2
  1220. .dicttomark readonly def
  1221.  
  1222. /resourcefont            % <font-resource> resourcefont <font>
  1223. { dup /PSFont .knownget
  1224.   { /FID knownoget { type /fonttype eq } { //false } ifelse }
  1225.   { //false }
  1226.   ifelse
  1227.   { /PSFont get }
  1228.   { dup dup /FontDescriptor knownoget {    % Stack: font-res font-res font-desc
  1229.       dup /FontObject .knownget {
  1230.     3 1 roll pop pop
  1231.       } {
  1232.     dup /FontFile knownoget
  1233.     { dup /Length oget 0 eq
  1234.       { pop pop dup /Subtype get fonttypeprocs exch get exec }
  1235.       { exch pop readtype1 }
  1236.       ifelse
  1237.     }
  1238.     { dup /FontFile2 knownoget
  1239.       { exch pop readtruetype }
  1240.       { /FontFile3 knownoget
  1241.         { dup /Subtype get fontloadprocs exch get exec }
  1242.             { dup /Subtype get fonttypeprocs exch get exec }
  1243.         ifelse
  1244.       }
  1245.       ifelse
  1246.     }
  1247.     ifelse
  1248.     1 index /FontDescriptor oget
  1249.     1 index /FontObject exch put        % Save pointer to the font
  1250.       }
  1251.       ifelse
  1252.     }
  1253.     { dup /Subtype get fonttypeprocs exch dup () cvn eq {
  1254.         (   **** Warning: Font missing required Subtype, /Type1 assumed.\n)
  1255.         pdfformaterror
  1256.         pop /Type1
  1257.       } if get exec
  1258.     }
  1259.     ifelse
  1260.     % Stack: font-res font
  1261.     1 index 3 1 roll
  1262.     1 index /Subtype get
  1263.     //adjustfonttypes exch .knownget { exec } { exch pop } ifelse
  1264.     dup 3 1 roll /PSFont exch put
  1265.   }
  1266.   ifelse
  1267. } bdef
  1268.  
  1269. drawopdict begin
  1270.   /d0 {
  1271.     .adjustcharwidth setcharwidth
  1272.   } bdef
  1273.   /d1 {
  1274.     4 index 0 ne {
  1275.       % invalid wy parameter for d1 in Type3 font (must be 0)
  1276.       % Even though the PDF 1.4 specification states that this must be 0,
  1277.       % Distiller sometimes creates Type3 fonts with non-zero wy. We set
  1278.       % it to 0 since this is apparently what Acrobat Reader 4 and 5 do,
  1279.       % but if the specification is ever changed to allow non-zero wy, this
  1280.       % will not work.
  1281.       5 -1 roll pop 0 5 1 roll      % set wy to 0
  1282.     } if
  1283.  
  1284.     2 copy                           % ... llx lly urx ury | urx ury 
  1285.     0 ne exch 0 ne                   % ... llx lly urx ury | ury!=0 urx!=0
  1286.     3 index 6 index eq and           % ... llx lly urx ury | ury!=0 (urx!=0 && llx==urx)
  1287.     exch 2 index 5 index eq and or { % ... llx lly urx ury | (urx!=0 && llx==urx) || (ury!=0 && lly==ury)
  1288.       % The bounding box is empty and likely incorrect. Don't cache.
  1289.       pop pop pop pop .adjustcharwidth setcharwidth
  1290.     } {
  1291.       6 -2 roll .adjustcharwidth 6 2 roll setcachedevice
  1292.     } ifelse
  1293.   } bdef
  1294.   /Tf {
  1295.     1 index Page /Font rget not { 1 index /invalidfont signalerror } if
  1296.     resourcefont exch Tf pop
  1297.   } bdef
  1298. end
  1299.  
  1300. end            % pdfdict
  1301. end            % GS_PDF_ProcSet
  1302. .setglobal
  1303.